package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;
import java.io.UnsupportedEncodingException;
import br.com.telescope.util.URLParameters;

/**
 * API de persistência de dados da entidade ITENS_MENUS
 * @author Gerado pelo Telescope
 */
public class EntItensMenus extends Entity {
    
    public final static String ENTITY_NAME = "RTMENU.ITENS_MENUS";
    public final static String TABLE_NAME = "ITENS_MENUS";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntItensMenus() {
        super();
        initialize();
    }
    
    public EntItensMenus(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aMenuId = new DomId(this,"MENU_ID", "Menu"); 
        aMenuId.setRequired(true);
        oMenuId = new DomId();
        aSequencia = new DomInteger(this,"SEQUENCIA", "Sequencia"); 
        oSequencia = new DomInteger();
        aTitulo = new DomText(this,"TITULO", "Título"); 
        aTitulo.setRequired(true);
        aTitulo.setSize(160);
        oTitulo = new DomText();
        aTituloCustomizado = new DomText(this,"TITULO_CUSTOMIZADO", "Título customizado"); 
        aTituloCustomizado.setSize(160);
        oTituloCustomizado = new DomText();
        aSubMenuId = new DomId(this,"SUB_MENU_ID", "Sub-menu"); 
        oSubMenuId = new DomId();
        aUrl = new DomUrl(this,"URL", "URL"); 
        aUrl.setSize(500);
        oUrl = new DomUrl();
        aPublico = new DomFlag(this,"PUBLICO", "Público"); 
        aPublico.setRequired(true);
        aPublico.setSize(1);
        aPublico.setDefaultValue("N");
        oPublico = new DomFlag();
        aInterfaceId = new DomId(this,"INTERFACE_ID", "Interface"); 
        oInterfaceId = new DomId();
        aParametros = new DomTextLong(this,"PARAMETROS", "Parâmetros"); 
        oParametros = new DomTextLong();
        aAtivo = new DomFlag(this,"ATIVO", "Ativo"); 
        aAtivo.setSize(1);
        aAtivo.setDefaultValue("S");
        oAtivo = new DomFlag();
        aCustomizado = new DomFlag(this,"CUSTOMIZADO", "Customizado"); 
        aCustomizado.setRequired(true);
        aCustomizado.setSize(1);
        aCustomizado.setDefaultValue("S");
        oCustomizado = new DomFlag();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Menu
    private DomId aMenuId;
    private DomId oMenuId;
    
    // Sequencia
    private DomInteger aSequencia;
    private DomInteger oSequencia;
    
    // Título
    private DomText aTitulo;
    private DomText oTitulo;
    
    // Título customizado
    private DomText aTituloCustomizado;
    private DomText oTituloCustomizado;
    
    // Sub-menu
    private DomId aSubMenuId;
    private DomId oSubMenuId;
    
    // URL
    private DomUrl aUrl;
    private DomUrl oUrl;
    
    // Público
    private DomFlag aPublico;
    private DomFlag oPublico;
    
    // Interface
    private DomId aInterfaceId;
    private DomId oInterfaceId;
    
    // Parâmetros
    private DomTextLong aParametros;
    private DomTextLong oParametros;
    
    // Ativo
    private DomFlag aAtivo;
    private DomFlag oAtivo;
    
    // Customizado
    private DomFlag aCustomizado;
    private DomFlag oCustomizado;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntItensMenus id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo MENU_ID">
    
    public EntItensMenus menuId(Long value) {
        setMenuId(value);
        return this;
    }
    
    public void setMenuId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyMenuId();
        } else {
            aMenuId.setValue(value.getValue());
            if (aMenuId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMenuId(String value) {
        if (value == null) {
            nullifyMenuId();
        } else {
            aMenuId.setValue(value);
            if (aMenuId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setMenuId(Long value) {
        aMenuId.setValue(value);
        if (aMenuId.isModified()) {
            setModified(true);
        }
    }
    
    public void setMenuId(Object value) {
        aMenuId.setValue(value);
        if (aMenuId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyMenuId() {
        if (!aMenuId.isNull()) {
            aMenuId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getMenuId() {
        return aMenuId;
    }
    
    public DomId oldMenuId() {
        return oMenuId;
    }
    
    public Long valueOfMenuId() {
        return aMenuId.getValue();
    }
    
    public boolean isMenuIdModified() {
        return aMenuId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SEQUENCIA">
    
    public EntItensMenus sequencia(Integer value) {
        setSequencia(value);
        return this;
    }
    
    public void setSequencia(DomInteger value) {
        if (value == null || value.isNull()) {
            nullifySequencia();
        } else {
            aSequencia.setValue(value.getValue());
            if (aSequencia.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequencia(String value) {
        if (value == null) {
            nullifySequencia();
        } else {
            aSequencia.setValue(value);
            if (aSequencia.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSequencia(Integer value) {
        aSequencia.setValue(value);
        if (aSequencia.isModified()) {
            setModified(true);
        }
    }
    
    public void setSequencia(Object value) {
        aSequencia.setValue(value);
        if (aSequencia.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySequencia() {
        if (!aSequencia.isNull()) {
            aSequencia.setNull(true);
            setModified(true);
        }
    }
    
    public DomInteger getSequencia() {
        return aSequencia;
    }
    
    public DomInteger oldSequencia() {
        return oSequencia;
    }
    
    public Integer valueOfSequencia() {
        return aSequencia.getValue();
    }
    
    public boolean isSequenciaModified() {
        return aSequencia.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TITULO">
    
    public EntItensMenus titulo(String value) {
        setTitulo(value);
        return this;
    }
    
    public void setTitulo(DomText value) {
        if (value == null || value.isNull()) {
            nullifyTitulo();
        } else {
            aTitulo.setValue(value.getValue());
            if (aTitulo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTitulo(String value) {
        if (value == null) {
            nullifyTitulo();
        } else {
            aTitulo.setValue(value);
            if (aTitulo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTitulo(Object value) {
        aTitulo.setValue(value);
        if (aTitulo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTitulo() {
        if (!aTitulo.isNull()) {
            aTitulo.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getTitulo() {
        return aTitulo;
    }
    
    public DomText oldTitulo() {
        return oTitulo;
    }
    
    public String valueOfTitulo() {
        return aTitulo.getValue();
    }
    
    public boolean isTituloModified() {
        return aTitulo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TITULO_CUSTOMIZADO">
    
    public EntItensMenus tituloCustomizado(String value) {
        setTituloCustomizado(value);
        return this;
    }
    
    public void setTituloCustomizado(DomText value) {
        if (value == null || value.isNull()) {
            nullifyTituloCustomizado();
        } else {
            aTituloCustomizado.setValue(value.getValue());
            if (aTituloCustomizado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTituloCustomizado(String value) {
        if (value == null) {
            nullifyTituloCustomizado();
        } else {
            aTituloCustomizado.setValue(value);
            if (aTituloCustomizado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTituloCustomizado(Object value) {
        aTituloCustomizado.setValue(value);
        if (aTituloCustomizado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTituloCustomizado() {
        if (!aTituloCustomizado.isNull()) {
            aTituloCustomizado.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getTituloCustomizado() {
        return aTituloCustomizado;
    }
    
    public DomText oldTituloCustomizado() {
        return oTituloCustomizado;
    }
    
    public String valueOfTituloCustomizado() {
        return aTituloCustomizado.getValue();
    }
    
    public boolean isTituloCustomizadoModified() {
        return aTituloCustomizado.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo SUB_MENU_ID">
    
    public EntItensMenus subMenuId(Long value) {
        setSubMenuId(value);
        return this;
    }
    
    public void setSubMenuId(DomId value) {
        if (value == null || value.isNull()) {
            nullifySubMenuId();
        } else {
            aSubMenuId.setValue(value.getValue());
            if (aSubMenuId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSubMenuId(String value) {
        if (value == null) {
            nullifySubMenuId();
        } else {
            aSubMenuId.setValue(value);
            if (aSubMenuId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setSubMenuId(Long value) {
        aSubMenuId.setValue(value);
        if (aSubMenuId.isModified()) {
            setModified(true);
        }
    }
    
    public void setSubMenuId(Object value) {
        aSubMenuId.setValue(value);
        if (aSubMenuId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifySubMenuId() {
        if (!aSubMenuId.isNull()) {
            aSubMenuId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getSubMenuId() {
        return aSubMenuId;
    }
    
    public DomId oldSubMenuId() {
        return oSubMenuId;
    }
    
    public Long valueOfSubMenuId() {
        return aSubMenuId.getValue();
    }
    
    public boolean isSubMenuIdModified() {
        return aSubMenuId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo URL">
    
    public EntItensMenus url(String value) {
        setUrl(value);
        return this;
    }
    
    public void setUrl(DomUrl value) {
        if (value == null || value.isNull()) {
            nullifyUrl();
        } else {
            aUrl.setValue(value.getValue());
            if (aUrl.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUrl(String value) {
        if (value == null) {
            nullifyUrl();
        } else {
            aUrl.setValue(value);
            if (aUrl.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setUrl(Object value) {
        aUrl.setValue(value);
        if (aUrl.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyUrl() {
        if (!aUrl.isNull()) {
            aUrl.setNull(true);
            setModified(true);
        }
    }
    
    public DomUrl getUrl() {
        return aUrl;
    }
    
    public DomUrl oldUrl() {
        return oUrl;
    }
    
    public String valueOfUrl() {
        return aUrl.getValue();
    }
    
    public boolean isUrlModified() {
        return aUrl.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PUBLICO">
    
    public EntItensMenus publico(String value) {
        setPublico(value);
        return this;
    }
    
    public void setPublico(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyPublico();
        } else {
            aPublico.setValue(value.getValue());
            if (aPublico.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPublico(String value) {
        if (value == null) {
            nullifyPublico();
        } else {
            aPublico.setValue(value);
            if (aPublico.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setPublico(Object value) {
        aPublico.setValue(value);
        if (aPublico.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyPublico() {
        if (!aPublico.isNull()) {
            aPublico.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getPublico() {
        return aPublico;
    }
    
    public DomFlag oldPublico() {
        return oPublico;
    }
    
    public String valueOfPublico() {
        return aPublico.getValue();
    }
    
    public boolean isPublicoModified() {
        return aPublico.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo INTERFACE_ID">
    
    public EntItensMenus interfaceId(Long value) {
        setInterfaceId(value);
        return this;
    }
    
    public void setInterfaceId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyInterfaceId();
        } else {
            aInterfaceId.setValue(value.getValue());
            if (aInterfaceId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setInterfaceId(String value) {
        if (value == null) {
            nullifyInterfaceId();
        } else {
            aInterfaceId.setValue(value);
            if (aInterfaceId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setInterfaceId(Long value) {
        aInterfaceId.setValue(value);
        if (aInterfaceId.isModified()) {
            setModified(true);
        }
    }
    
    public void setInterfaceId(Object value) {
        aInterfaceId.setValue(value);
        if (aInterfaceId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyInterfaceId() {
        if (!aInterfaceId.isNull()) {
            aInterfaceId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getInterfaceId() {
        return aInterfaceId;
    }
    
    public DomId oldInterfaceId() {
        return oInterfaceId;
    }
    
    public Long valueOfInterfaceId() {
        return aInterfaceId.getValue();
    }
    
    public boolean isInterfaceIdModified() {
        return aInterfaceId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo PARAMETROS">
    
    public EntItensMenus parametros(String value) {
        setParametros(value);
        return this;
    }
    
    public void setParametros(DomTextLong value) {
        if (value == null || value.isNull()) {
            nullifyParametros();
        } else {
            aParametros.setValue(value.getValue());
            if (aParametros.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setParametros(String value) {
        if (value == null) {
            nullifyParametros();
        } else {
            aParametros.setValue(value);
            if (aParametros.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setParametros(Object value) {
        aParametros.setValue(value);
        if (aParametros.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyParametros() {
        if (!aParametros.isNull()) {
            aParametros.setNull(true);
            setModified(true);
        }
    }
    
    public DomTextLong getParametros() {
        return aParametros;
    }
    
    public DomTextLong oldParametros() {
        return oParametros;
    }
    
    public String valueOfParametros() {
        return aParametros.getValue();
    }
    
    public boolean isParametrosModified() {
        return aParametros.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ATIVO">
    
    public EntItensMenus ativo(String value) {
        setAtivo(value);
        return this;
    }
    
    public void setAtivo(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyAtivo();
        } else {
            aAtivo.setValue(value.getValue());
            if (aAtivo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAtivo(String value) {
        if (value == null) {
            nullifyAtivo();
        } else {
            aAtivo.setValue(value);
            if (aAtivo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setAtivo(Object value) {
        aAtivo.setValue(value);
        if (aAtivo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyAtivo() {
        if (!aAtivo.isNull()) {
            aAtivo.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getAtivo() {
        return aAtivo;
    }
    
    public DomFlag oldAtivo() {
        return oAtivo;
    }
    
    public String valueOfAtivo() {
        return aAtivo.getValue();
    }
    
    public boolean isAtivoModified() {
        return aAtivo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo CUSTOMIZADO">
    
    public EntItensMenus customizado(String value) {
        setCustomizado(value);
        return this;
    }
    
    public void setCustomizado(DomFlag value) {
        if (value == null || value.isNull()) {
            nullifyCustomizado();
        } else {
            aCustomizado.setValue(value.getValue());
            if (aCustomizado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCustomizado(String value) {
        if (value == null) {
            nullifyCustomizado();
        } else {
            aCustomizado.setValue(value);
            if (aCustomizado.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setCustomizado(Object value) {
        aCustomizado.setValue(value);
        if (aCustomizado.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyCustomizado() {
        if (!aCustomizado.isNull()) {
            aCustomizado.setNull(true);
            setModified(true);
        }
    }
    
    public DomFlag getCustomizado() {
        return aCustomizado;
    }
    
    public DomFlag oldCustomizado() {
        return oCustomizado;
    }
    
    public String valueOfCustomizado() {
        return aCustomizado.getValue();
    }
    
    public boolean isCustomizadoModified() {
        return aCustomizado.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            e = new AdsException("RTMENU.ITENS_MENUS.GET_ERRORS_UNKNOWN",
                    AdsException.UNKNOWN,
                    "Erro não esperado: " + errorMsg);
        } else {
            if (msg.indexOf("ARC_ITME") >= 0) {
                e = new AdsException("RTMENU.ITENS_MENUS.ARC_ITME", 
                        Severity.ERROR,
                        "Regra inválida! URL, interface ou sub-menu devem estar preenchidos (apenas e obrigatoriamente um)! (ARC_ITME)");
                return e;
            } else if (msg.indexOf("FK_SUB_MENU") >= 0) {
                e = new AdsException("RTMENU.ITENS_MENUS.FK_SUB_MENU", 
                        Severity.ERROR,
                        "Registro não cadastrado para SUB_MENU! (FK_SUB_MENU)");
                return e;
            } else if (msg.indexOf("FK_MENU") >= 0) {
                e = new AdsException("RTMENU.ITENS_MENUS.FK_MENU", 
                        Severity.ERROR,
                        "Registro não cadastrado para MENU! (FK_MENU)");
                return e;
            } else if (msg.indexOf("BR_URL_PARAMETER") >= 0) {
                e = new AdsException("RTMENU.ITENS_MENUS.BR_URL_PARAMETER", 
                        Severity.ERROR,
                        "Regra inválida! Parâmetro deve ser informado apenas para interfaces ou URLs (BR_URL_PARAMETER)");
                return e;
            } else if (msg.indexOf("FK_INTERFACE_ITME") >= 0) {
                e = new AdsException("RTMENU.ITENS_MENUS.FK_INTERFACE_ITME", 
                        Severity.ERROR,
                        "Registro não cadastrado para INTERFACE! (FK_INTERFACE_ITME)");
                return e;
            } else if (msg.indexOf("PK_ITNMEN") >= 0) {
                e = new AdsException("RTMENU.ITENS_MENUS.PK_ITNMEN", 
                        Severity.ERROR,
                        "ID duplicado! (PK_ITNMEN)");
                return e;
            } else if (msg.indexOf("UK_TITULO") >= 0) {
                e = new AdsException("RTMENU.ITENS_MENUS.UK_TITULO", 
                        Severity.ERROR,
                        "Registro duplicado! Já existe um item do menu cadastrado com este título! Menu ${MENU_ID}, Título ${TITULO} (UK_TITULO)");
                return e;
            } else {
                e = new AdsException("RTMENU.ITENS_MENUS.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aMenuId);
            allAttributes.add(aSequencia);
            allAttributes.add(aTitulo);
            allAttributes.add(aTituloCustomizado);
            allAttributes.add(aSubMenuId);
            allAttributes.add(aUrl);
            allAttributes.add(aPublico);
            allAttributes.add(aInterfaceId);
            allAttributes.add(aParametros);
            allAttributes.add(aAtivo);
            allAttributes.add(aCustomizado);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getMenuId().toString() +
                " " + getTitulo().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByMenuIdTitulo(long menuId, String titulo) throws AdsException {
        findBy(new String[] {"MENU_ID", "TITULO"},
                new Object[] {menuId, titulo});
    }
    
    private EntMenus eSubMenu;
    
    public EntMenus findSubMenu() throws AdsException {
        if (getSubMenuId().isNull()) {
            return null;
        }
        if (eSubMenu == null || !valueOfSubMenuId().equals(eSubMenu.valueOfId())) {
            eSubMenu = new EntMenus(ctx);
            eSubMenu.find(valueOfSubMenuId());
        }
        return eSubMenu;
    }
    
    /**
     * Ativa o join desta entidade com MENUS
     * através do atributo SUB_MENU_ID
     */
    public EntMenus joinSubMenu() {
        return joinSubMenu(null);
    }
    public EntMenus joinSubMenu(String alias) {
        EntMenus entity = new EntMenus(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getSubMenuId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findBySubMenu(long id, String sqlAppend) throws AdsException {
        find("select ID from ITENS_MENUS where SUB_MENU_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findBySubMenu(long id) throws AdsException {
        findBySubMenu(id,"");
    }
    
    public void findBySubMenu(Entity entidade) throws AdsException {
        findBySubMenu(entidade.valueOfId(),"");
    }
    
    public void findBySubMenu(Entity entidade, String sqlAppend) throws AdsException {
        findBySubMenu(entidade.valueOfId(),sqlAppend);
    }
    
    private EntMenus eMenu;
    
    public EntMenus findMenu() throws AdsException {
        if (getMenuId().isNull()) {
            return null;
        }
        if (eMenu == null || !valueOfMenuId().equals(eMenu.valueOfId())) {
            eMenu = new EntMenus(ctx);
            eMenu.find(valueOfMenuId());
        }
        return eMenu;
    }
    
    /**
     * Ativa o join desta entidade com MENUS
     * através do atributo MENU_ID
     */
    public EntMenus joinMenu() {
        return joinMenu(null);
    }
    public EntMenus joinMenu(String alias) {
        EntMenus entity = new EntMenus(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getMenuId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByMenu(long id, String sqlAppend) throws AdsException {
        find("select ID from ITENS_MENUS where MENU_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByMenu(long id) throws AdsException {
        findByMenu(id,"");
    }
    
    public void findByMenu(Entity entidade) throws AdsException {
        findByMenu(entidade.valueOfId(),"");
    }
    
    public void findByMenu(Entity entidade, String sqlAppend) throws AdsException {
        findByMenu(entidade.valueOfId(),sqlAppend);
    }
    
    private EntInterfacesSistemas eInterface;
    
    public EntInterfacesSistemas findInterface() throws AdsException {
        if (getInterfaceId().isNull()) {
            return null;
        }
        if (eInterface == null || !valueOfInterfaceId().equals(eInterface.valueOfId())) {
            eInterface = new EntInterfacesSistemas(ctx);
            eInterface.find(valueOfInterfaceId());
        }
        return eInterface;
    }
    
    /**
     * Ativa o join desta entidade com INTERFACES_SISTEMAS
     * através do atributo INTERFACE_ID
     */
    public EntInterfacesSistemas joinInterface() {
        return joinInterface(null);
    }
    public EntInterfacesSistemas joinInterface(String alias) {
        EntInterfacesSistemas entity = new EntInterfacesSistemas(ctx);
        if (alias != null) {
            entity.setAlias(alias);
        }
        Join newJoin = new Join(getInterfaceId(), entity);
        entity.setJoinedBy(newJoin);
        this.join(newJoin);
        return entity;
    }
    
    public void findByInterface(long id, String sqlAppend) throws AdsException {
        find("select ID from ITENS_MENUS where INTERFACE_ID = ? " + sqlAppend);
        sqlSetLong(1,id);
    }
    
    public void findByInterface(long id) throws AdsException {
        findByInterface(id,"");
    }
    
    public void findByInterface(Entity entidade) throws AdsException {
        findByInterface(entidade.valueOfId(),"");
    }
    
    public void findByInterface(Entity entidade, String sqlAppend) throws AdsException {
        findByInterface(entidade.valueOfId(),sqlAppend);
    }
    
    /**
     * Limpa os objetos normalizados da entidade
     */
    public void clearRelatedObjects() {
        eSubMenu = null;
        eMenu = null;
        eInterface = null;
    }
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oTitulo.setValue(aTitulo);
        oInterfaceId.setValue(aInterfaceId);
        oId.setValue(aId);
        oSubMenuId.setValue(aSubMenuId);
        oSequencia.setValue(aSequencia);
        oPublico.setValue(aPublico);
        oUrl.setValue(aUrl);
        oParametros.setValue(aParametros);
        oMenuId.setValue(aMenuId);
        oAtivo.setValue(aAtivo);
        oCustomizado.setValue(aCustomizado);
        oTituloCustomizado.setValue(aTituloCustomizado);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntItensMenus.class);
            rule.setName("UK_TITULO");
            rule.addAttribute(new DomId("MENU_ID",""));
            rule.addAttribute(new DomText("TITULO",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntItensMenus.class);
            rule.setAssociatedEntity(EntMenus.class);
            rule.setName("FK_SUB_MENU");
            rule.addAttribute(new DomId("SUB_MENU_ID",""));
            out.add(rule);
        }
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntItensMenus.class);
            rule.setName("PK_ITNMEN");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntItensMenus.class);
            rule.setAssociatedEntity(EntMenus.class);
            rule.setName("FK_MENU");
            rule.addAttribute(new DomId("MENU_ID",""));
            out.add(rule);
        }
        {
            ForeignKeyRule rule = new ForeignKeyRule();
            rule.setEntity(EntItensMenus.class);
            rule.setAssociatedEntity(EntInterfacesSistemas.class);
            rule.setName("FK_INTERFACE_ITME");
            rule.addAttribute(new DomId("INTERFACE_ID",""));
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    protected void preInsert() throws AdsException {
        evitarRecursividade(); //Evitar recursividade
        checkRule(isBrUrlParameterValid(), "BR_URL_PARAMETER", "Parâmetro deve ser informado apenas para interfaces ou URLs");
        checkRule(isArcItmeValid(), "ARC_ITME", "URL, interface ou sub-menu devem estar preenchidos (apenas e obrigatoriamente um)!");
    }
    
    @Override
    protected void preUpdate() throws AdsException {
        evitarRecursividade(); //Evitar recursividade
        checkRule(isBrUrlParameterValid(), "BR_URL_PARAMETER", "Parâmetro deve ser informado apenas para interfaces ou URLs");
        checkRule(isArcItmeValid(), "ARC_ITME", "URL, interface ou sub-menu devem estar preenchidos (apenas e obrigatoriamente um)!");
    }
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getPublico().isNull()) {
            setPublico(getPublico().getDefaultValue());
        }
        if (getAtivo().isNull()) {
            setAtivo(getAtivo().getDefaultValue());
        }
        if (getCustomizado().isNull()) {
            setCustomizado(getCustomizado().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * Get url item.
     * <p>
     * Retorna a URL que deve ser utilizada para chamar o respectivo item de 
     * menu.
     * <P>
     * A URL é montada conforme os dados que foram estabelecidos para o item 
     * de menu. Pode ser uma URL fixa ou uma URL para uma determinada 
     * interface (Serviço). Quando parâmetros forem identificados, os mesmos 
     * são automaticamente adicionados e codificados adequadamente.
     * <P>
     */
    public String getUrlItem() throws AdsException {
        // <user-code id="751603" parentId="751602" hashcode="-3a75ea0d" length="1641">
        // import java.io.UnsupportedEncodingException;
        // import br.com.telescope.util.URLParameters;
        
        StringBuilder urlItem = new StringBuilder();
        if (getUrl().isNotNull()) { 
            urlItem.append( valueOfUrl() );
        } else if (getInterfaceId().isNotNull()) { 
            EntInterfacesSistemas intf = findInterface();
            if ( intf.userHasAccessToInterface() ) {
                int p = intf.valueOfNome().lastIndexOf(".");
                urlItem.append(AdsGenNames.getJavaClassName(intf.valueOfNome().substring(p)));
            } else {
                return "";
            }
        } else {
            return "";
        }
        
        if (getParametros().isNotNull()) {
            String[] lista;
            if (valueOfParametros().indexOf("\r\n") >= 0) {
                lista = valueOfParametros().trim().split("\r\n");
            } else if (valueOfParametros().indexOf("\n\r") >= 0) {
                lista = valueOfParametros().trim().split("\n\r");
            } else if (valueOfParametros().indexOf("\n") >= 0) {
                lista = valueOfParametros().trim().split("\n");
            } else {
                lista = valueOfParametros().trim().split("\r");
            }
        
            try {
                URLParameters urlparam = new URLParameters();
                for (int i = 0; i < lista.length; i++) {
                    String[] param = lista[i].split("=");
                    String p = param[0];  // nome do parâmetro
                    String v = param[1];  // valor do parâmetro
                    urlparam.put ( p, v );
                }
                urlItem.append ("?" + urlparam.getURLParameters());
            } catch (UnsupportedEncodingException ex) {
            }
        }
        
        return "<li>" +
                "<a href='" + urlItem.toString() + "'>" +
                "<nobr>" + valueOfTitulo() + "</nobr></a>" +
                "</li>"; 
        
        // </user-code>
    }
    
    /**
     * Regra de validação: Parâmetro deve ser informado apenas para interfaces ou URLs
     */
    private Object isBrUrlParameterValid() throws AdsException {
        // <user-code id="751599" parentId="751598" hashcode="6f7c1854" length="94">
        return getParametros().isNull() || ( getParametros().isNotNull() && getSubMenuId().isNull() );
        // </user-code>
    }
    
    /**
     * Regra de validação: URL, interface ou sub-menu devem estar preenchidos (apenas e obrigatoriamente um)!
     */
    private Object isArcItmeValid() throws AdsException {
        // <user-code id="841495" parentId="751594" hashcode="615ada4e" length="336">
        int i = 0;
        if (getInterfaceId().isNotNull()) i++;
        if (getSubMenuId().isNotNull()) i++;
        if (getUrl().isNotNull()) i++;
        if (valueOfTitulo().equals("-")) i++;
        if (i == 1) {
            return null;
        } else {
            return "O item \""
                    + valueOfTitulo() + "\" do menu "
                    + findMenu().valueOfMenu() + " não á válido!";
        }
        // </user-code>
    }
    
    /**
     * Regra de ação: Evitar recursividade
     * 
     * Verificar se este ítem não cria um loop infinito na hierarquia dos 
     * menus.
     */
    private void evitarRecursividade() throws AdsException {
        // <user-code id="751605" parentId="751604" hashcode="-3c884623" length="271">
        if (getSubMenuId().isNotNull() && findSubMenu().hasMenu(valueOfMenuId())) {
            throw new AdsException(ENTITY_NAME + ".INVALID_RECURSIVITY",
                    AdsException.ERROR,
                    "Este item de menu causa uma recursividade infinita da hierarquia de menus!");
        }
        
        // </user-code>
    }
}
